home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / w00w00 / exploits / tests / pcnfsd / pcnfsd_xdr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-13  |  20.0 KB  |  1,216 lines
  1. /*
  2.  * Please do not edit this file.
  3.  * It was generated using rpcgen.
  4.  */
  5.  
  6. #include <rpc/types.h>
  7. #include <rpc/xdr.h>
  8.  
  9. #include "pcnfsd.h"
  10.  
  11. bool_t
  12. xdr_ident(XDR *xdrs, ident *objp)
  13. {
  14.  
  15.      register long *buf;
  16. (void)buf;
  17.  
  18.      if (!xdr_string(xdrs, objp, IDENTLEN)) {
  19.          return (FALSE);
  20.      }
  21.     return (TRUE);
  22. }
  23.  
  24. bool_t
  25. xdr_message(XDR *xdrs, message *objp)
  26. {
  27.  
  28.      register long *buf;
  29. (void)buf;
  30.  
  31.      if (!xdr_string(xdrs, objp, MESSAGELEN)) {
  32.          return (FALSE);
  33.      }
  34.     return (TRUE);
  35. }
  36.  
  37. bool_t
  38. xdr_password(XDR *xdrs, password *objp)
  39. {
  40.  
  41.      register long *buf;
  42. (void)buf;
  43.  
  44.      if (!xdr_string(xdrs, objp, PASSWORDLEN)) {
  45.          return (FALSE);
  46.      }
  47.     return (TRUE);
  48. }
  49.  
  50. bool_t
  51. xdr_client(XDR *xdrs, client *objp)
  52. {
  53.  
  54.      register long *buf;
  55. (void)buf;
  56.  
  57.      if (!xdr_string(xdrs, objp, CLIENTLEN)) {
  58.          return (FALSE);
  59.      }
  60.     return (TRUE);
  61. }
  62.  
  63. bool_t
  64. xdr_printername(XDR *xdrs, printername *objp)
  65. {
  66.  
  67.      register long *buf;
  68. (void)buf;
  69.  
  70.      if (!xdr_string(xdrs, objp, PRINTERNAMELEN)) {
  71.          return (FALSE);
  72.      }
  73.     return (TRUE);
  74. }
  75.  
  76. bool_t
  77. xdr_username(XDR *xdrs, username *objp)
  78. {
  79.  
  80.      register long *buf;
  81. (void)buf;
  82.  
  83.      if (!xdr_string(xdrs, objp, USERNAMELEN)) {
  84.          return (FALSE);
  85.      }
  86.     return (TRUE);
  87. }
  88.  
  89. bool_t
  90. xdr_comment(XDR *xdrs, comment *objp)
  91. {
  92.  
  93.      register long *buf;
  94. (void)buf;
  95.  
  96.      if (!xdr_string(xdrs, objp, COMMENTLEN)) {
  97.          return (FALSE);
  98.      }
  99.     return (TRUE);
  100. }
  101.  
  102. bool_t
  103. xdr_spoolname(XDR *xdrs, spoolname *objp)
  104. {
  105.  
  106.      register long *buf;
  107. (void)buf;
  108.  
  109.      if (!xdr_string(xdrs, objp, SPOOLNAMELEN)) {
  110.          return (FALSE);
  111.      }
  112.     return (TRUE);
  113. }
  114.  
  115. bool_t
  116. xdr_printjobid(XDR *xdrs, printjobid *objp)
  117. {
  118.  
  119.      register long *buf;
  120. (void)buf;
  121.  
  122.      if (!xdr_string(xdrs, objp, PRINTJOBIDLEN)) {
  123.          return (FALSE);
  124.      }
  125.     return (TRUE);
  126. }
  127.  
  128. bool_t
  129. xdr_homedir(XDR *xdrs, homedir *objp)
  130. {
  131.  
  132.      register long *buf;
  133. (void)buf;
  134.  
  135.      if (!xdr_string(xdrs, objp, OPTIONSLEN)) {
  136.          return (FALSE);
  137.      }
  138.     return (TRUE);
  139. }
  140.  
  141. bool_t
  142. xdr_options(XDR *xdrs, options *objp)
  143. {
  144.  
  145.      register long *buf;
  146. (void)buf;
  147.  
  148.      if (!xdr_string(xdrs, objp, OPTIONSLEN)) {
  149.          return (FALSE);
  150.      }
  151.     return (TRUE);
  152. }
  153.  
  154. bool_t
  155. xdr_arstat(XDR *xdrs, arstat *objp)
  156. {
  157.  
  158.      register long *buf;
  159. (void)buf;
  160.  
  161.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  162.          return (FALSE);
  163.      }
  164.     return (TRUE);
  165. }
  166.  
  167. bool_t
  168. xdr_alrstat(XDR *xdrs, alrstat *objp)
  169. {
  170.  
  171.      register long *buf;
  172. (void)buf;
  173.  
  174.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  175.          return (FALSE);
  176.      }
  177.     return (TRUE);
  178. }
  179.  
  180. bool_t
  181. xdr_pirstat(XDR *xdrs, pirstat *objp)
  182. {
  183.  
  184.      register long *buf;
  185. (void)buf;
  186.  
  187.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  188.          return (FALSE);
  189.      }
  190.     return (TRUE);
  191. }
  192.  
  193. bool_t
  194. xdr_pcrstat(XDR *xdrs, pcrstat *objp)
  195. {
  196.  
  197.      register long *buf;
  198. (void)buf;
  199.  
  200.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  201.          return (FALSE);
  202.      }
  203.     return (TRUE);
  204. }
  205.  
  206. bool_t
  207. xdr_psrstat(XDR *xdrs, psrstat *objp)
  208. {
  209.  
  210.      register long *buf;
  211. (void)buf;
  212.  
  213.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  214.          return (FALSE);
  215.      }
  216.     return (TRUE);
  217. }
  218.  
  219. bool_t
  220. xdr_mapreq(XDR *xdrs, mapreq *objp)
  221. {
  222.  
  223.      register long *buf;
  224. (void)buf;
  225.  
  226.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  227.          return (FALSE);
  228.      }
  229.     return (TRUE);
  230. }
  231.  
  232. bool_t
  233. xdr_maprstat(XDR *xdrs, maprstat *objp)
  234. {
  235.  
  236.      register long *buf;
  237. (void)buf;
  238.  
  239.      if (!xdr_enum(xdrs, (enum_t *)objp)) {
  240.          return (FALSE);
  241.      }
  242.     return (TRUE);
  243. }
  244.  
  245. bool_t
  246. xdr_auth_args(XDR *xdrs, auth_args *objp)
  247. {
  248.  
  249.      register long *buf;
  250. (void)buf;
  251.  
  252.      if (!xdr_ident(xdrs, &objp->id)) {
  253.          return (FALSE);
  254.      }
  255.      if (!xdr_password(xdrs, &objp->pw)) {
  256.          return (FALSE);
  257.      }
  258.     return (TRUE);
  259. }
  260.  
  261. bool_t
  262. xdr_auth_results(XDR *xdrs, auth_results *objp)
  263. {
  264.  
  265.      register long *buf;
  266. (void)buf;
  267.  
  268.      if (!xdr_arstat(xdrs, &objp->stat)) {
  269.          return (FALSE);
  270.      }
  271.      if (!xdr_u_int(xdrs, &objp->uid)) {
  272.          return (FALSE);
  273.      }
  274.      if (!xdr_u_int(xdrs, &objp->gid)) {
  275.          return (FALSE);
  276.      }
  277.     return (TRUE);
  278. }
  279.  
  280. bool_t
  281. xdr_pr_init_args(XDR *xdrs, pr_init_args *objp)
  282. {
  283.  
  284.      register long *buf;
  285. (void)buf;
  286.  
  287.      if (!xdr_client(xdrs, &objp->system)) {
  288.          return (FALSE);
  289.      }
  290.      if (!xdr_printername(xdrs, &objp->pn)) {
  291.          return (FALSE);
  292.      }
  293.     return (TRUE);
  294. }
  295.  
  296. bool_t
  297. xdr_pr_init_results(XDR *xdrs, pr_init_results *objp)
  298. {
  299.  
  300.      register long *buf;
  301. (void)buf;
  302.  
  303.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  304.          return (FALSE);
  305.      }
  306.      if (!xdr_spoolname(xdrs, &objp->dir)) {
  307.          return (FALSE);
  308.      }
  309.     return (TRUE);
  310. }
  311.  
  312. bool_t
  313. xdr_pr_start_args(XDR *xdrs, pr_start_args *objp)
  314. {
  315.  
  316.      register long *buf;
  317. (void)buf;
  318.  
  319.      if (!xdr_client(xdrs, &objp->system)) {
  320.          return (FALSE);
  321.      }
  322.      if (!xdr_printername(xdrs, &objp->pn)) {
  323.          return (FALSE);
  324.      }
  325.      if (!xdr_username(xdrs, &objp->user)) {
  326.          return (FALSE);
  327.      }
  328.      if (!xdr_spoolname(xdrs, &objp->file)) {
  329.          return (FALSE);
  330.      }
  331.      if (!xdr_options(xdrs, &objp->opts)) {
  332.          return (FALSE);
  333.      }
  334.     return (TRUE);
  335. }
  336.  
  337. bool_t
  338. xdr_pr_start_results(XDR *xdrs, pr_start_results *objp)
  339. {
  340.  
  341.      register long *buf;
  342. (void)buf;
  343.  
  344.      if (!xdr_psrstat(xdrs, &objp->stat)) {
  345.          return (FALSE);
  346.      }
  347.     return (TRUE);
  348. }
  349.  
  350. bool_t
  351. xdr_v2_info_args(XDR *xdrs, v2_info_args *objp)
  352. {
  353.  
  354.      register long *buf;
  355. (void)buf;
  356.  
  357.      if (!xdr_comment(xdrs, &objp->vers)) {
  358.          return (FALSE);
  359.      }
  360.      if (!xdr_comment(xdrs, &objp->cm)) {
  361.          return (FALSE);
  362.      }
  363.     return (TRUE);
  364. }
  365.  
  366. bool_t
  367. xdr_v2_info_results(XDR *xdrs, v2_info_results *objp)
  368. {
  369.  
  370.      register long *buf;
  371. (void)buf;
  372.  
  373.      if (!xdr_comment(xdrs, &objp->vers)) {
  374.          return (FALSE);
  375.      }
  376.      if (!xdr_comment(xdrs, &objp->cm)) {
  377.          return (FALSE);
  378.      }
  379.      if (!xdr_array(xdrs, (char **)&objp->facilities.facilities_val, (u_int *)&objp->facilities.facilities_len, FACILITIESMAX, sizeof(int), (xdrproc_t)xdr_int)) {
  380.          return (FALSE);
  381.      }
  382.     return (TRUE);
  383. }
  384.  
  385. bool_t
  386. xdr_v2_pr_init_args(XDR *xdrs, v2_pr_init_args *objp)
  387. {
  388.  
  389.      register long *buf;
  390. (void)buf;
  391.  
  392.      if (!xdr_client(xdrs, &objp->system)) {
  393.          return (FALSE);
  394.      }
  395.      if (!xdr_printername(xdrs, &objp->pn)) {
  396.          return (FALSE);
  397.      }
  398.      if (!xdr_comment(xdrs, &objp->cm)) {
  399.          return (FALSE);
  400.      }
  401.     return (TRUE);
  402. }
  403.  
  404. bool_t
  405. xdr_v2_pr_init_results(XDR *xdrs, v2_pr_init_results *objp)
  406. {
  407.  
  408.      register long *buf;
  409. (void)buf;
  410.  
  411.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  412.          return (FALSE);
  413.      }
  414.      if (!xdr_spoolname(xdrs, &objp->dir)) {
  415.          return (FALSE);
  416.      }
  417.      if (!xdr_comment(xdrs, &objp->cm)) {
  418.          return (FALSE);
  419.      }
  420.     return (TRUE);
  421. }
  422.  
  423. bool_t
  424. xdr_v2_pr_start_args(XDR *xdrs, v2_pr_start_args *objp)
  425. {
  426.  
  427.      register long *buf;
  428. (void)buf;
  429.  
  430.      if (!xdr_client(xdrs, &objp->system)) {
  431.          return (FALSE);
  432.      }
  433.      if (!xdr_printername(xdrs, &objp->pn)) {
  434.          return (FALSE);
  435.      }
  436.      if (!xdr_username(xdrs, &objp->user)) {
  437.          return (FALSE);
  438.      }
  439.      if (!xdr_spoolname(xdrs, &objp->file)) {
  440.          return (FALSE);
  441.      }
  442.      if (!xdr_options(xdrs, &objp->opts)) {
  443.          return (FALSE);
  444.      }
  445.      if (!xdr_int(xdrs, &objp->copies)) {
  446.          return (FALSE);
  447.      }
  448.      if (!xdr_comment(xdrs, &objp->cm)) {
  449.          return (FALSE);
  450.      }
  451.     return (TRUE);
  452. }
  453.  
  454. bool_t
  455. xdr_v2_pr_start_results(XDR *xdrs, v2_pr_start_results *objp)
  456. {
  457.  
  458.      register long *buf;
  459. (void)buf;
  460.  
  461.      if (!xdr_psrstat(xdrs, &objp->stat)) {
  462.          return (FALSE);
  463.      }
  464.      if (!xdr_printjobid(xdrs, &objp->id)) {
  465.          return (FALSE);
  466.      }
  467.      if (!xdr_comment(xdrs, &objp->cm)) {
  468.          return (FALSE);
  469.      }
  470.     return (TRUE);
  471. }
  472.  
  473. bool_t
  474. xdr_pr_list(XDR *xdrs, pr_list *objp)
  475. {
  476.  
  477.      register long *buf;
  478. (void)buf;
  479.  
  480.      if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct pr_list_item), (xdrproc_t)xdr_pr_list_item)) {
  481.          return (FALSE);
  482.      }
  483.     return (TRUE);
  484. }
  485.  
  486. bool_t
  487. xdr_pr_list_item(XDR *xdrs, pr_list_item *objp)
  488. {
  489.  
  490.      register long *buf;
  491. (void)buf;
  492.  
  493.      if (!xdr_printername(xdrs, &objp->pn)) {
  494.          return (FALSE);
  495.      }
  496.      if (!xdr_printername(xdrs, &objp->device)) {
  497.          return (FALSE);
  498.      }
  499.      if (!xdr_client(xdrs, &objp->remhost)) {
  500.          return (FALSE);
  501.      }
  502.      if (!xdr_comment(xdrs, &objp->cm)) {
  503.          return (FALSE);
  504.      }
  505.      if (!xdr_pr_list(xdrs, &objp->pr_next)) {
  506.          return (FALSE);
  507.      }
  508.     return (TRUE);
  509. }
  510.  
  511. bool_t
  512. xdr_v2_pr_list_results(XDR *xdrs, v2_pr_list_results *objp)
  513. {
  514.  
  515.      register long *buf;
  516. (void)buf;
  517.  
  518.      if (!xdr_comment(xdrs, &objp->cm)) {
  519.          return (FALSE);
  520.      }
  521.      if (!xdr_pr_list(xdrs, &objp->printers)) {
  522.          return (FALSE);
  523.      }
  524.     return (TRUE);
  525. }
  526.  
  527. bool_t
  528. xdr_v2_pr_queue_args(XDR *xdrs, v2_pr_queue_args *objp)
  529. {
  530.  
  531.      register long *buf;
  532. (void)buf;
  533.  
  534.      if (!xdr_printername(xdrs, &objp->pn)) {
  535.          return (FALSE);
  536.      }
  537.      if (!xdr_client(xdrs, &objp->system)) {
  538.          return (FALSE);
  539.      }
  540.      if (!xdr_username(xdrs, &objp->user)) {
  541.          return (FALSE);
  542.      }
  543.      if (!xdr_bool(xdrs, &objp->just_mine)) {
  544.          return (FALSE);
  545.      }
  546.      if (!xdr_comment(xdrs, &objp->cm)) {
  547.          return (FALSE);
  548.      }
  549.     return (TRUE);
  550. }
  551.  
  552. bool_t
  553. xdr_pr_queue(XDR *xdrs, pr_queue *objp)
  554. {
  555.  
  556.      register long *buf;
  557. (void)buf;
  558.  
  559.      if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct pr_queue_item), (xdrproc_t)xdr_pr_queue_item)) {
  560.          return (FALSE);
  561.      }
  562.     return (TRUE);
  563. }
  564.  
  565. bool_t
  566. xdr_pr_queue_item(XDR *xdrs, pr_queue_item *objp)
  567. {
  568.  
  569.      register long *buf;
  570. (void)buf;
  571.  
  572.      if (!xdr_int(xdrs, &objp->position)) {
  573.          return (FALSE);
  574.      }
  575.      if (!xdr_printjobid(xdrs, &objp->id)) {
  576.          return (FALSE);
  577.      }
  578.      if (!xdr_comment(xdrs, &objp->size)) {
  579.          return (FALSE);
  580.      }
  581.      if (!xdr_comment(xdrs, &objp->status)) {
  582.          return (FALSE);
  583.      }
  584.      if (!xdr_client(xdrs, &objp->system)) {
  585.          return (FALSE);
  586.      }
  587.      if (!xdr_username(xdrs, &objp->user)) {
  588.          return (FALSE);
  589.      }
  590.      if (!xdr_spoolname(xdrs, &objp->file)) {
  591.          return (FALSE);
  592.      }
  593.      if (!xdr_comment(xdrs, &objp->cm)) {
  594.          return (FALSE);
  595.      }
  596.      if (!xdr_pr_queue(xdrs, &objp->pr_next)) {
  597.          return (FALSE);
  598.      }
  599.     return (TRUE);
  600. }
  601.  
  602. bool_t
  603. xdr_v2_pr_queue_results(XDR *xdrs, v2_pr_queue_results *objp)
  604. {
  605.  
  606.      register long *buf;
  607. (void)buf;
  608.  
  609.  
  610.      if (xdrs->x_op == XDR_ENCODE) {
  611.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  612.          return (FALSE);
  613.      }
  614.      if (!xdr_comment(xdrs, &objp->cm)) {
  615.          return (FALSE);
  616.      }
  617.      buf = XDR_INLINE(xdrs,3 * BYTES_PER_XDR_UNIT);
  618.        if (buf == NULL) {
  619.          if (!xdr_bool(xdrs, &objp->just_yours)) {
  620.              return (FALSE);
  621.          }
  622.          if (!xdr_int(xdrs, &objp->qlen)) {
  623.              return (FALSE);
  624.          }
  625.          if (!xdr_int(xdrs, &objp->qshown)) {
  626.              return (FALSE);
  627.          }
  628.  
  629.       }
  630.       else {
  631.          IXDR_PUT_BOOL(buf,objp->just_yours);
  632.          IXDR_PUT_LONG(buf,objp->qlen);
  633.          IXDR_PUT_LONG(buf,objp->qshown);
  634.       }
  635.      if (!xdr_pr_queue(xdrs, &objp->jobs)) {
  636.          return (FALSE);
  637.      }
  638.  
  639.       return (TRUE);
  640.     } else if (xdrs->x_op == XDR_DECODE) {
  641.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  642.          return (FALSE);
  643.      }
  644.      if (!xdr_comment(xdrs, &objp->cm)) {
  645.          return (FALSE);
  646.      }
  647.      buf = XDR_INLINE(xdrs,3 * BYTES_PER_XDR_UNIT);
  648.        if (buf == NULL) {
  649.          if (!xdr_bool(xdrs, &objp->just_yours)) {
  650.              return (FALSE);
  651.          }
  652.          if (!xdr_int(xdrs, &objp->qlen)) {
  653.              return (FALSE);
  654.          }
  655.          if (!xdr_int(xdrs, &objp->qshown)) {
  656.              return (FALSE);
  657.          }
  658.  
  659.       }
  660.       else {
  661.          objp->just_yours = IXDR_GET_BOOL(buf);
  662.          objp->qlen = IXDR_GET_LONG(buf);
  663.          objp->qshown = IXDR_GET_LONG(buf);
  664.       }
  665.      if (!xdr_pr_queue(xdrs, &objp->jobs)) {
  666.          return (FALSE);
  667.      }
  668.      return(TRUE);
  669.     }
  670.  
  671.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  672.          return (FALSE);
  673.      }
  674.      if (!xdr_comment(xdrs, &objp->cm)) {
  675.          return (FALSE);
  676.      }
  677.      if (!xdr_bool(xdrs, &objp->just_yours)) {
  678.          return (FALSE);
  679.      }
  680.      if (!xdr_int(xdrs, &objp->qlen)) {
  681.          return (FALSE);
  682.      }
  683.      if (!xdr_int(xdrs, &objp->qshown)) {
  684.          return (FALSE);
  685.      }
  686.      if (!xdr_pr_queue(xdrs, &objp->jobs)) {
  687.          return (FALSE);
  688.      }
  689.     return (TRUE);
  690. }
  691.  
  692. bool_t
  693. xdr_v2_pr_cancel_args(XDR *xdrs, v2_pr_cancel_args *objp)
  694. {
  695.  
  696.      register long *buf;
  697. (void)buf;
  698.  
  699.      if (!xdr_printername(xdrs, &objp->pn)) {
  700.          return (FALSE);
  701.      }
  702.      if (!xdr_client(xdrs, &objp->system)) {
  703.          return (FALSE);
  704.      }
  705.      if (!xdr_username(xdrs, &objp->user)) {
  706.          return (FALSE);
  707.      }
  708.      if (!xdr_printjobid(xdrs, &objp->id)) {
  709.          return (FALSE);
  710.      }
  711.      if (!xdr_comment(xdrs, &objp->cm)) {
  712.          return (FALSE);
  713.      }
  714.     return (TRUE);
  715. }
  716.  
  717. bool_t
  718. xdr_v2_pr_cancel_results(XDR *xdrs, v2_pr_cancel_results *objp)
  719. {
  720.  
  721.      register long *buf;
  722. (void)buf;
  723.  
  724.      if (!xdr_pcrstat(xdrs, &objp->stat)) {
  725.          return (FALSE);
  726.      }
  727.      if (!xdr_comment(xdrs, &objp->cm)) {
  728.          return (FALSE);
  729.      }
  730.     return (TRUE);
  731. }
  732.  
  733. bool_t
  734. xdr_v2_pr_status_args(XDR *xdrs, v2_pr_status_args *objp)
  735. {
  736.  
  737.      register long *buf;
  738. (void)buf;
  739.  
  740.      if (!xdr_printername(xdrs, &objp->pn)) {
  741.          return (FALSE);
  742.      }
  743.      if (!xdr_comment(xdrs, &objp->cm)) {
  744.          return (FALSE);
  745.      }
  746.     return (TRUE);
  747. }
  748.  
  749. bool_t
  750. xdr_v2_pr_status_results(XDR *xdrs, v2_pr_status_results *objp)
  751. {
  752.  
  753.      register long *buf;
  754. (void)buf;
  755.  
  756.  
  757.      if (xdrs->x_op == XDR_ENCODE) {
  758.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  759.          return (FALSE);
  760.      }
  761.      buf = XDR_INLINE(xdrs,4 * BYTES_PER_XDR_UNIT);
  762.        if (buf == NULL) {
  763.          if (!xdr_bool(xdrs, &objp->avail)) {
  764.              return (FALSE);
  765.          }
  766.          if (!xdr_bool(xdrs, &objp->printing)) {
  767.              return (FALSE);
  768.          }
  769.          if (!xdr_int(xdrs, &objp->qlen)) {
  770.              return (FALSE);
  771.          }
  772.          if (!xdr_bool(xdrs, &objp->needs_operator)) {
  773.              return (FALSE);
  774.          }
  775.  
  776.       }
  777.       else {
  778.          IXDR_PUT_BOOL(buf,objp->avail);
  779.          IXDR_PUT_BOOL(buf,objp->printing);
  780.          IXDR_PUT_LONG(buf,objp->qlen);
  781.          IXDR_PUT_BOOL(buf,objp->needs_operator);
  782.       }
  783.      if (!xdr_comment(xdrs, &objp->status)) {
  784.          return (FALSE);
  785.      }
  786.      if (!xdr_comment(xdrs, &objp->cm)) {
  787.          return (FALSE);
  788.      }
  789.  
  790.       return (TRUE);
  791.     } else if (xdrs->x_op == XDR_DECODE) {
  792.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  793.          return (FALSE);
  794.      }
  795.      buf = XDR_INLINE(xdrs,4 * BYTES_PER_XDR_UNIT);
  796.        if (buf == NULL) {
  797.          if (!xdr_bool(xdrs, &objp->avail)) {
  798.              return (FALSE);
  799.          }
  800.          if (!xdr_bool(xdrs, &objp->printing)) {
  801.              return (FALSE);
  802.          }
  803.          if (!xdr_int(xdrs, &objp->qlen)) {
  804.              return (FALSE);
  805.          }
  806.          if (!xdr_bool(xdrs, &objp->needs_operator)) {
  807.              return (FALSE);
  808.          }
  809.  
  810.       }
  811.       else {
  812.          objp->avail = IXDR_GET_BOOL(buf);
  813.          objp->printing = IXDR_GET_BOOL(buf);
  814.          objp->qlen = IXDR_GET_LONG(buf);
  815.          objp->needs_operator = IXDR_GET_BOOL(buf);
  816.       }
  817.      if (!xdr_comment(xdrs, &objp->status)) {
  818.          return (FALSE);
  819.      }
  820.      if (!xdr_comment(xdrs, &objp->cm)) {
  821.          return (FALSE);
  822.      }
  823.      return(TRUE);
  824.     }
  825.  
  826.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  827.          return (FALSE);
  828.      }
  829.      if (!xdr_bool(xdrs, &objp->avail)) {
  830.          return (FALSE);
  831.      }
  832.      if (!xdr_bool(xdrs, &objp->printing)) {
  833.          return (FALSE);
  834.      }
  835.      if (!xdr_int(xdrs, &objp->qlen)) {
  836.          return (FALSE);
  837.      }
  838.      if (!xdr_bool(xdrs, &objp->needs_operator)) {
  839.          return (FALSE);
  840.      }
  841.      if (!xdr_comment(xdrs, &objp->status)) {
  842.          return (FALSE);
  843.      }
  844.      if (!xdr_comment(xdrs, &objp->cm)) {
  845.          return (FALSE);
  846.      }
  847.     return (TRUE);
  848. }
  849.  
  850. bool_t
  851. xdr_v2_pr_admin_args(XDR *xdrs, v2_pr_admin_args *objp)
  852. {
  853.  
  854.      register long *buf;
  855. (void)buf;
  856.  
  857.      if (!xdr_client(xdrs, &objp->system)) {
  858.          return (FALSE);
  859.      }
  860.      if (!xdr_username(xdrs, &objp->user)) {
  861.          return (FALSE);
  862.      }
  863.      if (!xdr_printername(xdrs, &objp->pn)) {
  864.          return (FALSE);
  865.      }
  866.      if (!xdr_comment(xdrs, &objp->cm)) {
  867.          return (FALSE);
  868.      }
  869.     return (TRUE);
  870. }
  871.  
  872. bool_t
  873. xdr_v2_pr_admin_results(XDR *xdrs, v2_pr_admin_results *objp)
  874. {
  875.  
  876.      register long *buf;
  877. (void)buf;
  878.  
  879.      if (!xdr_pirstat(xdrs, &objp->stat)) {
  880.          return (FALSE);
  881.      }
  882.      if (!xdr_comment(xdrs, &objp->cm)) {
  883.          return (FALSE);
  884.      }
  885.     return (TRUE);
  886. }
  887.  
  888. bool_t
  889. xdr_v2_pr_requeue_args(XDR *xdrs, v2_pr_requeue_args *objp)
  890. {
  891.  
  892.      register long *buf;
  893. (void)buf;
  894.  
  895.      if (!xdr_printername(xdrs, &objp->pn)) {
  896.          return (FALSE);
  897.      }
  898.      if (!xdr_client(xdrs, &objp->system)) {
  899.          return (FALSE);
  900.      }
  901.      if (!xdr_username(xdrs, &objp->user)) {
  902.          return (FALSE);
  903.      }
  904.      if (!xdr_printjobid(xdrs, &objp->id)) {
  905.          return (FALSE);
  906.      }
  907.      if (!xdr_int(xdrs, &objp->qpos)) {
  908.          return (FALSE);
  909.      }
  910.      if (!xdr_comment(xdrs, &objp->cm)) {
  911.          return (FALSE);
  912.      }
  913.     return (TRUE);
  914. }
  915.  
  916. bool_t
  917. xdr_v2_pr_requeue_results(XDR *xdrs, v2_pr_requeue_results *objp)
  918. {
  919.  
  920.      register long *buf;
  921. (void)buf;
  922.  
  923.      if (!xdr_pcrstat(xdrs, &objp->stat)) {
  924.          return (FALSE);
  925.      }
  926.      if (!xdr_comment(xdrs, &objp->cm)) {
  927.          return (FALSE);
  928.      }
  929.     return (TRUE);
  930. }
  931.  
  932. bool_t
  933. xdr_v2_pr_hold_args(XDR *xdrs, v2_pr_hold_args *objp)
  934. {
  935.  
  936.      register long *buf;
  937. (void)buf;
  938.  
  939.      if (!xdr_printername(xdrs, &objp->pn)) {
  940.          return (FALSE);
  941.      }
  942.      if (!xdr_client(xdrs, &objp->system)) {
  943.          return (FALSE);
  944.      }
  945.      if (!xdr_username(xdrs, &objp->user)) {
  946.          return (FALSE);
  947.      }
  948.      if (!xdr_printjobid(xdrs, &objp->id)) {
  949.          return (FALSE);
  950.      }
  951.      if (!xdr_comment(xdrs, &objp->cm)) {
  952.          return (FALSE);
  953.      }
  954.     return (TRUE);
  955. }
  956.  
  957. bool_t
  958. xdr_v2_pr_hold_results(XDR *xdrs, v2_pr_hold_results *objp)
  959. {
  960.  
  961.      register long *buf;
  962. (void)buf;
  963.  
  964.      if (!xdr_pcrstat(xdrs, &objp->stat)) {
  965.          return (FALSE);
  966.      }
  967.      if (!xdr_comment(xdrs, &objp->cm)) {
  968.          return (FALSE);
  969.      }
  970.     return (TRUE);
  971. }
  972.  
  973. bool_t
  974. xdr_v2_pr_release_args(XDR *xdrs, v2_pr_release_args *objp)
  975. {
  976.  
  977.      register long *buf;
  978. (void)buf;
  979.  
  980.      if (!xdr_printername(xdrs, &objp->pn)) {
  981.          return (FALSE);
  982.      }
  983.      if (!xdr_client(xdrs, &objp->system)) {
  984.          return (FALSE);
  985.      }
  986.      if (!xdr_username(xdrs, &objp->user)) {
  987.          return (FALSE);
  988.      }
  989.      if (!xdr_printjobid(xdrs, &objp->id)) {
  990.          return (FALSE);
  991.      }
  992.      if (!xdr_comment(xdrs, &objp->cm)) {
  993.          return (FALSE);
  994.      }
  995.     return (TRUE);
  996. }
  997.  
  998. bool_t
  999. xdr_v2_pr_release_results(XDR *xdrs, v2_pr_release_results *objp)
  1000. {
  1001.  
  1002.      register long *buf;
  1003. (void)buf;
  1004.  
  1005.      if (!xdr_pcrstat(xdrs, &objp->stat)) {
  1006.          return (FALSE);
  1007.      }
  1008.      if (!xdr_comment(xdrs, &objp->cm)) {
  1009.          return (FALSE);
  1010.      }
  1011.     return (TRUE);
  1012. }
  1013.  
  1014. bool_t
  1015. xdr_mapreq_arg(XDR *xdrs, mapreq_arg *objp)
  1016. {
  1017.  
  1018.      register long *buf;
  1019. (void)buf;
  1020.  
  1021.      if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mapreq_arg_item), (xdrproc_t)xdr_mapreq_arg_item)) {
  1022.          return (FALSE);
  1023.      }
  1024.     return (TRUE);
  1025. }
  1026.  
  1027. bool_t
  1028. xdr_mapreq_arg_item(XDR *xdrs, mapreq_arg_item *objp)
  1029. {
  1030.  
  1031.      register long *buf;
  1032. (void)buf;
  1033.  
  1034.      if (!xdr_mapreq(xdrs, &objp->req)) {
  1035.          return (FALSE);
  1036.      }
  1037.      if (!xdr_int(xdrs, &objp->id)) {
  1038.          return (FALSE);
  1039.      }
  1040.      if (!xdr_username(xdrs, &objp->name)) {
  1041.          return (FALSE);
  1042.      }
  1043.      if (!xdr_mapreq_arg(xdrs, &objp->mapreq_next)) {
  1044.          return (FALSE);
  1045.      }
  1046.     return (TRUE);
  1047. }
  1048.  
  1049. bool_t
  1050. xdr_mapreq_res(XDR *xdrs, mapreq_res *objp)
  1051. {
  1052.  
  1053.      register long *buf;
  1054. (void)buf;
  1055.  
  1056.      if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mapreq_res_item), (xdrproc_t)xdr_mapreq_res_item)) {
  1057.          return (FALSE);
  1058.      }
  1059.     return (TRUE);
  1060. }
  1061.  
  1062. bool_t
  1063. xdr_mapreq_res_item(XDR *xdrs, mapreq_res_item *objp)
  1064. {
  1065.  
  1066.      register long *buf;
  1067. (void)buf;
  1068.  
  1069.      if (!xdr_mapreq(xdrs, &objp->req)) {
  1070.          return (FALSE);
  1071.      }
  1072.      if (!xdr_maprstat(xdrs, &objp->stat)) {
  1073.          return (FALSE);
  1074.      }
  1075.      if (!xdr_int(xdrs, &objp->id)) {
  1076.          return (FALSE);
  1077.      }
  1078.      if (!xdr_username(xdrs, &objp->name)) {
  1079.          return (FALSE);
  1080.      }
  1081.      if (!xdr_mapreq_res(xdrs, &objp->mapreq_next)) {
  1082.          return (FALSE);
  1083.      }
  1084.     return (TRUE);
  1085. }
  1086.  
  1087. bool_t
  1088. xdr_v2_mapid_args(XDR *xdrs, v2_mapid_args *objp)
  1089. {
  1090.  
  1091.      register long *buf;
  1092. (void)buf;
  1093.  
  1094.      if (!xdr_comment(xdrs, &objp->cm)) {
  1095.          return (FALSE);
  1096.      }
  1097.      if (!xdr_mapreq_arg(xdrs, &objp->req_list)) {
  1098.          return (FALSE);
  1099.      }
  1100.     return (TRUE);
  1101. }
  1102.  
  1103. bool_t
  1104. xdr_v2_mapid_results(XDR *xdrs, v2_mapid_results *objp)
  1105. {
  1106.  
  1107.      register long *buf;
  1108. (void)buf;
  1109.  
  1110.      if (!xdr_comment(xdrs, &objp->cm)) {
  1111.          return (FALSE);
  1112.      }
  1113.      if (!xdr_mapreq_res(xdrs, &objp->res_list)) {
  1114.          return (FALSE);
  1115.      }
  1116.     return (TRUE);
  1117. }
  1118.  
  1119. bool_t
  1120. xdr_v2_auth_args(XDR *xdrs, v2_auth_args *objp)
  1121. {
  1122.  
  1123.      register long *buf;
  1124. (void)buf;
  1125.  
  1126.      if (!xdr_client(xdrs, &objp->system)) {
  1127.          return (FALSE);
  1128.      }
  1129.      if (!xdr_ident(xdrs, &objp->id)) {
  1130.          return (FALSE);
  1131.      }
  1132.      if (!xdr_password(xdrs, &objp->pw)) {
  1133.          return (FALSE);
  1134.      }
  1135.      if (!xdr_comment(xdrs, &objp->cm)) {
  1136.          return (FALSE);
  1137.      }
  1138.     return (TRUE);
  1139. }
  1140.  
  1141. bool_t
  1142. xdr_v2_auth_results(XDR *xdrs, v2_auth_results *objp)
  1143. {
  1144.  
  1145.      register long *buf;
  1146. (void)buf;
  1147.  
  1148.      if (!xdr_arstat(xdrs, &objp->stat)) {
  1149.          return (FALSE);
  1150.      }
  1151.      if (!xdr_u_int(xdrs, &objp->uid)) {
  1152.          return (FALSE);
  1153.      }
  1154.      if (!xdr_u_int(xdrs, &objp->gid)) {
  1155.          return (FALSE);
  1156.      }
  1157.      if (!xdr_array(xdrs, (char **)&objp->gids.gids_val, (u_int *)&objp->gids.gids_len, EXTRAGIDLEN, sizeof(u_int), (xdrproc_t)xdr_u_int)) {
  1158.          return (FALSE);
  1159.      }
  1160.      if (!xdr_homedir(xdrs, &objp->home)) {
  1161.          return (FALSE);
  1162.      }
  1163.      if (!xdr_int(xdrs, &objp->def_umask)) {
  1164.          return (FALSE);
  1165.      }
  1166.      if (!xdr_comment(xdrs, &objp->cm)) {
  1167.          return (FALSE);
  1168.      }
  1169.     return (TRUE);
  1170. }
  1171.  
  1172. bool_t
  1173. xdr_v2_alert_args(XDR *xdrs, v2_alert_args *objp)
  1174. {
  1175.  
  1176.      register long *buf;
  1177. (void)buf;
  1178.  
  1179.      if (!xdr_client(xdrs, &objp->system)) {
  1180.          return (FALSE);
  1181.      }
  1182.      if (!xdr_printername(xdrs, &objp->pn)) {
  1183.          return (FALSE);
  1184.      }
  1185.      if (!xdr_username(xdrs, &objp->user)) {
  1186.          return (FALSE);
  1187.      }
  1188.      if (!xdr_message(xdrs, &objp->msg)) {
  1189.          return (FALSE);
  1190.      }
  1191.     return (TRUE);
  1192. }
  1193.  
  1194. bool_t
  1195. xdr_v2_alert_results(XDR *xdrs, v2_alert_results *objp)
  1196. {
  1197.  
  1198.      register long *buf;
  1199. (void)buf;
  1200.  
  1201.      if (!xdr_alrstat(xdrs, &objp->stat)) {
  1202.          return (FALSE);
  1203.      }
  1204.      if (!xdr_comment(xdrs, &objp->cm)) {
  1205.          return (FALSE);
  1206.      }
  1207.     return (TRUE);
  1208. }
  1209. #if RPC_SVC
  1210.  static void _msgout();
  1211.  void msg_out(msg) char *msg; {_msgout(msg);}
  1212. #endif
  1213. #if RPC_HDR
  1214.  extern void msg_out();
  1215. #endif
  1216.